package cn.edu.scau.cmi.ema.dao;

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.springframework.dao.DataAccessException;

import org.springframework.stereotype.Repository;

import org.springframework.transaction.annotation.Transactional;

import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.Session;


import cn.edu.scau.cmi.ema.domain.*;
import cn.edu.scau.cmi.ema.domain.base.CmiPagination;


import cn.edu.scau.cmi.ema.util.CmiSqlUtil;

@Repository("CrawlereventDAO")
@Transactional
public class CrawlereventDAOImpl extends AbstractJpaDao<Crawlerevent> implements CrawlereventDAO {

	private final static Set<Class<?>> dataTypes = new HashSet<Class<?>>(
			Arrays.asList(new Class<?>[] { Crawlerevent.class }));

	@PersistenceContext(unitName = "ema")
	private EntityManager entityManager;

	public CrawlereventDAOImpl() {
		super();
	}

	public EntityManager getEntityManager() {
		return entityManager;
	}

	public Set<Class<?>> getTypes() {
		return dataTypes;
	}

	@Transactional
	public Crawlerevent findCrawlereventById(Integer id) throws DataAccessException {

		return findCrawlereventById(id, -1, -1);
	}

	@Transactional
	public Crawlerevent findCrawlereventById(Integer id, int startResult, int maxRows) throws DataAccessException {
		try {
			Query query = createNamedQuery("findCrawlereventById", startResult, maxRows, id);
			return (Crawlerevent) query.getSingleResult();
		} catch (NoResultException nre) {
			return null;
		}
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByName(String name) throws DataAccessException {

		return findCrawlereventByName(name, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByName(String name, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByName", startResult, maxRows, name);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByNameContaining(String name) throws DataAccessException {

		return findCrawlereventByNameContaining(name, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByNameContaining(String name, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByNameContaining", startResult, maxRows, name);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByFilename(String filename) throws DataAccessException {

		return findCrawlereventByFilename(filename, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByFilename(String filename, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByFilename", startResult, maxRows, filename);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByFilenameContaining(String filename) throws DataAccessException {

		return findCrawlereventByFilenameContaining(filename, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByFilenameContaining(String filename, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByFilenameContaining", startResult, maxRows, filename);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByRownumber(String rownumber) throws DataAccessException {

		return findCrawlereventByRownumber(rownumber, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByRownumber(String rownumber, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByRownumber", startResult, maxRows, rownumber);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByRownumberContaining(String rownumber) throws DataAccessException {

		return findCrawlereventByRownumberContaining(rownumber, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByRownumberContaining(String rownumber, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByRownumberContaining", startResult, maxRows, rownumber);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByMaxcolumn(String maxcolumn) throws DataAccessException {

		return findCrawlereventByMaxcolumn(maxcolumn, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByMaxcolumn(String maxcolumn, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByMaxcolumn", startResult, maxRows, maxcolumn);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByMaxcolumnContaining(String maxcolumn) throws DataAccessException {

		return findCrawlereventByMaxcolumnContaining(maxcolumn, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByMaxcolumnContaining(String maxcolumn, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByMaxcolumnContaining", startResult, maxRows, maxcolumn);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByMiscellaneous(String miscellaneous) throws DataAccessException {

		return findCrawlereventByMiscellaneous(miscellaneous, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByMiscellaneous(String miscellaneous, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByMiscellaneous", startResult, maxRows, miscellaneous);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByMiscellaneousContaining(String miscellaneous)
			throws DataAccessException {

		return findCrawlereventByMiscellaneousContaining(miscellaneous, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByMiscellaneousContaining(String miscellaneous, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByMiscellaneousContaining", startResult, maxRows,
				miscellaneous);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByBrand(String brand) throws DataAccessException {

		return findCrawlereventByBrand(brand, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByBrand(String brand, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByBrand", startResult, maxRows, brand);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByBrandContaining(String brand) throws DataAccessException {

		return findCrawlereventByBrandContaining(brand, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByBrandContaining(String brand, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByBrandContaining", startResult, maxRows, brand);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByRedetectapplier(String redetectapplier) throws DataAccessException {

		return findCrawlereventByRedetectapplier(redetectapplier, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByRedetectapplier(String redetectapplier, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByRedetectapplier", startResult, maxRows, redetectapplier);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByRedetectapplierContaining(String redetectapplier)
			throws DataAccessException {

		return findCrawlereventByRedetectapplierContaining(redetectapplier, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByRedetectapplierContaining(String redetectapplier, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByRedetectapplierContaining", startResult, maxRows,
				redetectapplier);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByRedetectresult(String redetectresult) throws DataAccessException {

		return findCrawlereventByRedetectresult(redetectresult, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByRedetectresult(String redetectresult, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByRedetectresult", startResult, maxRows, redetectresult);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByRedetectresultContaining(String redetectresult)
			throws DataAccessException {

		return findCrawlereventByRedetectresultContaining(redetectresult, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByRedetectresultContaining(String redetectresult, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByRedetectresultContaining", startResult, maxRows,
				redetectresult);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByNumber(String number) throws DataAccessException {

		return findCrawlereventByNumber(number, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByNumber(String number, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByNumber", startResult, maxRows, number);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByNumberContaining(String number) throws DataAccessException {

		return findCrawlereventByNumberContaining(number, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByNumberContaining(String number, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByNumberContaining", startResult, maxRows, number);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreecontent(String disagreecontent) throws DataAccessException {

		return findCrawlereventByDisagreecontent(disagreecontent, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreecontent(String disagreecontent, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDisagreecontent", startResult, maxRows, disagreecontent);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreecontentContaining(String disagreecontent)
			throws DataAccessException {

		return findCrawlereventByDisagreecontentContaining(disagreecontent, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreecontentContaining(String disagreecontent, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDisagreecontentContaining", startResult, maxRows,
				disagreecontent);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreedate(String disagreedate) throws DataAccessException {

		return findCrawlereventByDisagreedate(disagreedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreedate(String disagreedate, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDisagreedate", startResult, maxRows, disagreedate);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreedateContaining(String disagreedate) throws DataAccessException {

		return findCrawlereventByDisagreedateContaining(disagreedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreedateContaining(String disagreedate, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDisagreedateContaining", startResult, maxRows, disagreedate);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreeconclusion(String disagreeconclusion)
			throws DataAccessException {

		return findCrawlereventByDisagreeconclusion(disagreeconclusion, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreeconclusion(String disagreeconclusion, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDisagreeconclusion", startResult, maxRows,
				disagreeconclusion);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreeconclusionContaining(String disagreeconclusion)
			throws DataAccessException {

		return findCrawlereventByDisagreeconclusionContaining(disagreeconclusion, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreeconclusionContaining(String disagreeconclusion, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDisagreeconclusionContaining", startResult, maxRows,
				disagreeconclusion);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreeapply(String disagreeapply) throws DataAccessException {

		return findCrawlereventByDisagreeapply(disagreeapply, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreeapply(String disagreeapply, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDisagreeapply", startResult, maxRows, disagreeapply);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreeapplyContaining(String disagreeapply)
			throws DataAccessException {

		return findCrawlereventByDisagreeapplyContaining(disagreeapply, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDisagreeapplyContaining(String disagreeapply, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDisagreeapplyContaining", startResult, maxRows,
				disagreeapply);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByIsredetectapply(String isredetectapply) throws DataAccessException {

		return findCrawlereventByIsredetectapply(isredetectapply, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByIsredetectapply(String isredetectapply, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByIsredetectapply", startResult, maxRows, isredetectapply);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByIsredetectapplyContaining(String isredetectapply)
			throws DataAccessException {

		return findCrawlereventByIsredetectapplyContaining(isredetectapply, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByIsredetectapplyContaining(String isredetectapply, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByIsredetectapplyContaining", startResult, maxRows,
				isredetectapply);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectasksource(String detectasksource) throws DataAccessException {

		return findCrawlereventByDetectasksource(detectasksource, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectasksource(String detectasksource, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectasksource", startResult, maxRows, detectasksource);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectasksourceContaining(String detectasksource)
			throws DataAccessException {

		return findCrawlereventByDetectasksourceContaining(detectasksource, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectasksourceContaining(String detectasksource, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectasksourceContaining", startResult, maxRows,
				detectasksource);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectannounce(String detectannounce) throws DataAccessException {

		return findCrawlereventByDetectannounce(detectannounce, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectannounce(String detectannounce, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectannounce", startResult, maxRows, detectannounce);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectannounceContaining(String detectannounce)
			throws DataAccessException {

		return findCrawlereventByDetectannounceContaining(detectannounce, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectannounceContaining(String detectannounce, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectannounceContaining", startResult, maxRows,
				detectannounce);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectannouncedate(String detectannouncedate)
			throws DataAccessException {

		return findCrawlereventByDetectannouncedate(detectannouncedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectannouncedate(String detectannouncedate, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectannouncedate", startResult, maxRows,
				detectannouncedate);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectannouncedateContaining(String detectannouncedate)
			throws DataAccessException {

		return findCrawlereventByDetectannouncedateContaining(detectannouncedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectannouncedateContaining(String detectannouncedate, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectannouncedateContaining", startResult, maxRows,
				detectannouncedate);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectdate(String detectdate) throws DataAccessException {

		return findCrawlereventByDetectdate(detectdate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectdate(String detectdate, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectdate", startResult, maxRows, detectdate);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectdateContaining(String detectdate) throws DataAccessException {

		return findCrawlereventByDetectdateContaining(detectdate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectdateContaining(String detectdate, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectdateContaining", startResult, maxRows, detectdate);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectdepartment(String detectdepartment) throws DataAccessException {

		return findCrawlereventByDetectdepartment(detectdepartment, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectdepartment(String detectdepartment, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectdepartment", startResult, maxRows, detectdepartment);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectdepartmentContaining(String detectdepartment)
			throws DataAccessException {

		return findCrawlereventByDetectdepartmentContaining(detectdepartment, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectdepartmentContaining(String detectdepartment, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectdepartmentContaining", startResult, maxRows,
				detectdepartment);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectstandard(String detectstandard) throws DataAccessException {

		return findCrawlereventByDetectstandard(detectstandard, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectstandard(String detectstandard, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectstandard", startResult, maxRows, detectstandard);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectstandardContaining(String detectstandard)
			throws DataAccessException {

		return findCrawlereventByDetectstandardContaining(detectstandard, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectstandardContaining(String detectstandard, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectstandardContaining", startResult, maxRows,
				detectstandard);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectstandardvalue(String detectstandardvalue)
			throws DataAccessException {

		return findCrawlereventByDetectstandardvalue(detectstandardvalue, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectstandardvalue(String detectstandardvalue, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectstandardvalue", startResult, maxRows,
				detectstandardvalue);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectstandardvalueContaining(String detectstandardvalue)
			throws DataAccessException {

		return findCrawlereventByDetectstandardvalueContaining(detectstandardvalue, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectstandardvalueContaining(String detectstandardvalue,
			int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectstandardvalueContaining", startResult, maxRows,
				detectstandardvalue);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectfeature(String detectfeature) throws DataAccessException {

		return findCrawlereventByDetectfeature(detectfeature, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectfeature(String detectfeature, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectfeature", startResult, maxRows, detectfeature);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectfeatureContaining(String detectfeature)
			throws DataAccessException {

		return findCrawlereventByDetectfeatureContaining(detectfeature, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectfeatureContaining(String detectfeature, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectfeatureContaining", startResult, maxRows,
				detectfeature);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectlink(String detectlink) throws DataAccessException {

		return findCrawlereventByDetectlink(detectlink, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectlink(String detectlink, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectlink", startResult, maxRows, detectlink);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectlinkContaining(String detectlink) throws DataAccessException {

		return findCrawlereventByDetectlinkContaining(detectlink, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectlinkContaining(String detectlink, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectlinkContaining", startResult, maxRows, detectlink);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectresult(String detectresult) throws DataAccessException {

		return findCrawlereventByDetectresult(detectresult, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectresult(String detectresult, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectresult", startResult, maxRows, detectresult);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectresultContaining(String detectresult) throws DataAccessException {

		return findCrawlereventByDetectresultContaining(detectresult, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectresultContaining(String detectresult, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectresultContaining", startResult, maxRows, detectresult);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectnumber(String detectnumber) throws DataAccessException {

		return findCrawlereventByDetectnumber(detectnumber, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectnumber(String detectnumber, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectnumber", startResult, maxRows, detectnumber);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectnumberContaining(String detectnumber) throws DataAccessException {

		return findCrawlereventByDetectnumberContaining(detectnumber, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectnumberContaining(String detectnumber, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectnumberContaining", startResult, maxRows, detectnumber);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectdescription(String detectdescription) throws DataAccessException {

		return findCrawlereventByDetectdescription(detectdescription, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectdescription(String detectdescription, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectdescription", startResult, maxRows, detectdescription);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectdescriptionContaining(String detectdescription)
			throws DataAccessException {

		return findCrawlereventByDetectdescriptionContaining(detectdescription, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectdescriptionContaining(String detectdescription, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectdescriptionContaining", startResult, maxRows,
				detectdescription);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectproject(String detectproject) throws DataAccessException {

		return findCrawlereventByDetectproject(detectproject, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectproject(String detectproject, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectproject", startResult, maxRows, detectproject);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectprojectContaining(String detectproject)
			throws DataAccessException {

		return findCrawlereventByDetectprojectContaining(detectproject, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDetectprojectContaining(String detectproject, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDetectprojectContaining", startResult, maxRows,
				detectproject);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByProducer(String producer) throws DataAccessException {

		return findCrawlereventByProducer(producer, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByProducer(String producer, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByProducer", startResult, maxRows, producer);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByProducerContaining(String producer) throws DataAccessException {

		return findCrawlereventByProducerContaining(producer, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByProducerContaining(String producer, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByProducerContaining", startResult, maxRows, producer);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByProduceraddress(String produceraddress) throws DataAccessException {

		return findCrawlereventByProduceraddress(produceraddress, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByProduceraddress(String produceraddress, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByProduceraddress", startResult, maxRows, produceraddress);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByProduceraddressContaining(String produceraddress)
			throws DataAccessException {

		return findCrawlereventByProduceraddressContaining(produceraddress, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByProduceraddressContaining(String produceraddress, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByProduceraddressContaining", startResult, maxRows,
				produceraddress);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByProducedate(String producedate) throws DataAccessException {

		return findCrawlereventByProducedate(producedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByProducedate(String producedate, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByProducedate", startResult, maxRows, producedate);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByProducedateContaining(String producedate) throws DataAccessException {

		return findCrawlereventByProducedateContaining(producedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByProducedateContaining(String producedate, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByProducedateContaining", startResult, maxRows, producedate);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByNetplatform(String netplatform) throws DataAccessException {

		return findCrawlereventByNetplatform(netplatform, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByNetplatform(String netplatform, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByNetplatform", startResult, maxRows, netplatform);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByNetplatformContaining(String netplatform) throws DataAccessException {

		return findCrawlereventByNetplatformContaining(netplatform, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByNetplatformContaining(String netplatform, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByNetplatformContaining", startResult, maxRows, netplatform);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventBySubject(String subject) throws DataAccessException {

		return findCrawlereventBySubject(subject, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventBySubject(String subject, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventBySubject", startResult, maxRows, subject);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventBySubjectContaining(String subject) throws DataAccessException {

		return findCrawlereventBySubjectContaining(subject, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventBySubjectContaining(String subject, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventBySubjectContaining", startResult, maxRows, subject);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventBySubjectaddress(String subjectaddress) throws DataAccessException {

		return findCrawlereventBySubjectaddress(subjectaddress, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventBySubjectaddress(String subjectaddress, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventBySubjectaddress", startResult, maxRows, subjectaddress);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventBySubjectaddressContaining(String subjectaddress)
			throws DataAccessException {

		return findCrawlereventBySubjectaddressContaining(subjectaddress, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventBySubjectaddressContaining(String subjectaddress, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventBySubjectaddressContaining", startResult, maxRows,
				subjectaddress);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByPackagemethod(String packagemethod) throws DataAccessException {

		return findCrawlereventByPackagemethod(packagemethod, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByPackagemethod(String packagemethod, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByPackagemethod", startResult, maxRows, packagemethod);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByPackagemethodContaining(String packagemethod)
			throws DataAccessException {

		return findCrawlereventByPackagemethodContaining(packagemethod, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByPackagemethodContaining(String packagemethod, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByPackagemethodContaining", startResult, maxRows,
				packagemethod);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByPurchasedate(String purchasedate) throws DataAccessException {

		return findCrawlereventByPurchasedate(purchasedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByPurchasedate(String purchasedate, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByPurchasedate", startResult, maxRows, purchasedate);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByPurchasedateContaining(String purchasedate) throws DataAccessException {

		return findCrawlereventByPurchasedateContaining(purchasedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByPurchasedateContaining(String purchasedate, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByPurchasedateContaining", startResult, maxRows, purchasedate);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByFood(String food) throws DataAccessException {

		return findCrawlereventByFood(food, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByFood(String food, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByFood", startResult, maxRows, food);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByFoodContaining(String food) throws DataAccessException {

		return findCrawlereventByFoodContaining(food, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByFoodContaining(String food, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByFoodContaining", startResult, maxRows, food);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByFoodbatch(String foodbatch) throws DataAccessException {

		return findCrawlereventByFoodbatch(foodbatch, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByFoodbatch(String foodbatch, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByFoodbatch", startResult, maxRows, foodbatch);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByFoodbatchContaining(String foodbatch) throws DataAccessException {

		return findCrawlereventByFoodbatchContaining(foodbatch, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByFoodbatchContaining(String foodbatch, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByFoodbatchContaining", startResult, maxRows, foodbatch);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByFoodtype(String foodtype) throws DataAccessException {

		return findCrawlereventByFoodtype(foodtype, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByFoodtype(String foodtype, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByFoodtype", startResult, maxRows, foodtype);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByFoodtypeContaining(String foodtype) throws DataAccessException {

		return findCrawlereventByFoodtypeContaining(foodtype, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByFoodtypeContaining(String foodtype, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByFoodtypeContaining", startResult, maxRows, foodtype);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDescription(String description) throws DataAccessException {

		return findCrawlereventByDescription(description, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDescription(String description, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDescription", startResult, maxRows, description);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventByDescriptionContaining(String description) throws DataAccessException {

		return findCrawlereventByDescriptionContaining(description, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByDescriptionContaining(String description, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlereventByDescriptionContaining", startResult, maxRows, description);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@Transactional
	public Crawlerevent findCrawlereventByPrimaryKey(Integer id) throws DataAccessException {
		return findCrawlereventByPrimaryKey(id, -1, -1);
	}

	@Transactional
	public Crawlerevent findCrawlereventByPrimaryKey(Integer id, int startResult, int maxRows)
			throws DataAccessException {
		try {
			Query query = createNamedQuery("findCrawlereventByPrimaryKey", startResult, maxRows, id);
			return (Crawlerevent) query.getSingleResult();
		} catch (NoResultException nre) {
			return null;
		}
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventsByIds(Set<Integer> ids) throws DataAccessException {
		try {
			Query query = createNamedQuery("findCrawlereventsByIds", -1, -1, ids);
			return new HashSet(query.getResultList());
		} catch (NoResultException nre) {
			return null;
		}
	}

	@Transactional
	public Set<Crawlerevent> findAllCrawlerevents() throws DataAccessException {

		return findAllCrawlerevents(-1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findAllCrawlerevents(int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findAllCrawlerevents", startResult, maxRows);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@SuppressWarnings("unchecked")
	public Set<Crawlerevent> findCrawlereventsByCrawlerdetectstatus(Integer crawlerdetectstatusId, int start, int max)
			throws DataAccessException {
		Query query = createNamedQuery("findAllCrawlereventsByCrawlerdetectstatus", start, max, crawlerdetectstatusId);
		return new LinkedHashSet<Crawlerevent>(query.getResultList());
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerevent> findCrawlereventByCompositeProperities(String sql, int startResult, int maxRows) {
		return new LinkedHashSet<Crawlerevent>(createQuery(sql, startResult, maxRows).getResultList());
	}

	@Transactional
	public Set<Crawlerevent> findCrawlereventsByDetachedCriteria(CmiPagination page) throws DataAccessException {
		DetachedCriteria detachedCriteria = CmiSqlUtil.createDetachedCriteria(page, Crawlerevent.class);
		Session session = entityManager.unwrap(Session.class);
		Set<Crawlerevent> crawlerevents = new HashSet(detachedCriteria.getExecutableCriteria(session)
				.setFirstResult(page.getSearchBeginCursor()).setMaxResults(page.getPaginationSize()).list());

		return crawlerevents;
	}

	@Transactional
	public Crawlerevent findCrawlereventByPhysicalPrimaryKey(String filename, String rownumber)
			throws DataAccessException {
		return findCrawlereventByPhysicalPrimaryKey(filename, rownumber, -1, -1);
	}

	@Transactional
	public Crawlerevent findCrawlereventByPhysicalPrimaryKey(String filename, String rownumber, int startResult,
			int maxRows) throws DataAccessException {
		try {
			Query query = createNamedQuery("findCrawlereventByPhyscialPrimaryKey", startResult, maxRows, filename,
					rownumber);
			return (Crawlerevent) query.getSingleResult();
		} catch (NoResultException nre) {
			return null;
		}
	}

	public boolean canBeMerged(Crawlerevent entity) {
		return true;
	}
}
